﻿using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using TMPro;
using UnityEngine.EventSystems;
using System.Collections.Generic;
using UnityEngine.SceneManagement;

namespace TowerDefence
{
    public class GameManager : MonoBehaviour
    {
        #region 单例模式
        // 游戏管理器的单例实例
        public static GameManager instance;

        // 当物体被唤醒时调用的方法
        public void Awake()
        {
            // 检查是否已存在 GameManager 实例
            if (instance != null)
            {
                // 如果存在多个实例，输出错误信息并返回
                Debug.LogError("场景中存在多个 GameManager！");
                return;
            }
            instance = this; // 将当前实例设置为单例实例
        }
        #endregion

        // 脚本引用
        // PlayerDataManager playerDataManager;
        GameButtonManager buttonManager;
        AudioManager audioManager;
        PlayerStats playerStats;
        WaveManager waveManager;
        Rewards rewards;
        SceneFader fader;
        Camera cam;

        // UI 脚本
        UpdateTowerDualUpgradeUI dualTowerUpgradeUI;
        UpdateTowerUpgradeUI towerUpgradeUI;
        ConfirmationTowerUI confirmationTowerUI;

        // 选定建筑节点信息
        TowerData towerToBuild;
        [HideInInspector]
        public BuildNode selectedBuildNode;

        [Header("新敌人日志信息")]
        public EnemyLogInfoContainer newEnemyAlertWindow;
        public EnemyLogInfo newEnemyThisLevel;
        public int newEnemyIndex;

        //[Header("电池节能模式")]
        //public GameObject highEndPath;
        //public GameObject lowEndPath;
        //public TextMeshProUGUI toggleText;
        //public Image batteryButtonImage;
        //public Sprite onButtonSprite;
        //public Sprite offButtonSprite;

        // 布尔值
        public static bool GameIsOver;
        public static bool IsPaused;
        public static bool BeginGame;
        bool buttonActive;
        //bool isBatterySaving;
        [Space]
        [Header("胜利窗口 UI")]
        public TextMeshProUGUI moneyText;
        public TextMeshProUGUI gemText;
        public TextMeshProUGUI scoreText;
        public Image star01;
        public Image star02;
        public Image star03;
        public GameObject continueButton;
        private bool getScore;
        private int starScore;
        public int levelToUnlock = 2;
        [Space]
        #region UI 变量
        [Header("窗口 UI")]
        public GameObject backgroundImage;
        public GameObject confirmationWindow;
        public GameObject settingsWindow;
        public GameObject victoryWindow;
        public GameObject gameOverWindow;
        public GameObject upgradeWindow;
        public GameObject dualUpgradeWindow;
        public GameObject shopWindow;
        public GameObject tutorialWindow;
        public GameObject enemyInfoWindow;
        #endregion
        [Space]
        [Header("特效")]
        // 建造特效和出售特效的游戏对象
        public GameObject buildEffect;
        public GameObject sellEffect;

        [Space]
        // 当前场景
        private Scene currentScene;

        // 是否能够建造塔
        public bool CanBuild { get { return towerToBuild != null; } }
        // 是否能够购买塔（金币足够）
        public bool CanPurchase { get { return PlayerStats.Gold >= towerToBuild.cost; } }

        // 在游戏开始时调用的方法
        public void Start()
        {
            #region 游戏组件
            // 主摄像机
            cam = Camera.main;

            // 场景淡入淡出控制器
            fader = FindObjectOfType<SceneFader>();
            // 音频管理器
            audioManager = FindObjectOfType<AudioManager>();
            // 波次管理器
            waveManager = FindObjectOfType<WaveManager>();
            // 游戏按钮管理器
            buttonManager = FindObjectOfType<GameButtonManager>();

            // 奖励实例
            rewards = Rewards.instance;
            // 玩家状态实例
            playerStats = PlayerStats.instance;
            // 单一塔升级UI实例
            towerUpgradeUI = UpdateTowerUpgradeUI.instance;
            // 双塔升级UI实例
            dualTowerUpgradeUI = UpdateTowerDualUpgradeUI.instance;
            // 塔确认UI实例
            confirmationTowerUI = ConfirmationTowerUI.instance;

            // 清除确认塔UI按钮监听器
            confirmationTowerUI.yesButton.onClick.RemoveAllListeners();
            confirmationTowerUI.noButton.onClick.RemoveAllListeners();
            // 清除塔升级UI按钮监听器
            towerUpgradeUI.upgradeButton.onClick.RemoveAllListeners();
            towerUpgradeUI.sellButon.onClick.RemoveAllListeners();
            towerUpgradeUI.swapButton.onClick.RemoveAllListeners();
            // 清除双塔升级UI按钮监听器
            dualTowerUpgradeUI.upgradeButton01.onClick.RemoveAllListeners();
            dualTowerUpgradeUI.upgradeButton02.onClick.RemoveAllListeners();
            dualTowerUpgradeUI.sellButon.onClick.RemoveAllListeners();
            dualTowerUpgradeUI.swapButton.onClick.RemoveAllListeners();

            // 添加确认塔UI中"是"按钮的监听器，点击时实例化塔
            confirmationTowerUI.yesButton.onClick.AddListener(InstantiateTowerButton);
            // 添加确认塔UI中"否"按钮的监听器，点击时关闭确认窗口
            confirmationTowerUI.noButton.onClick.AddListener(CloseConfirmationWindow);
            // 添加塔升级UI中"升级"按钮的监听器，点击时执行升级塔的操作
            towerUpgradeUI.upgradeButton.onClick.AddListener(UpgradeTowerButton01);
            // 添加塔升级UI中"出售"按钮的监听器，点击时执行出售塔的操作
            towerUpgradeUI.sellButon.onClick.AddListener(SellTowerButton);
            // 添加塔升级UI中"交换"按钮的监听器，点击时执行交换塔的操作
            towerUpgradeUI.swapButton.onClick.AddListener(towerUpgradeUI.SwapButton);
            // 添加双塔升级UI中"升级1"按钮的监听器，点击时执行升级塔的操作
            dualTowerUpgradeUI.upgradeButton01.onClick.AddListener(UpgradeTowerButton01);
            // 添加双塔升级UI中"升级2"按钮的监听器，点击时执行升级塔的操作
            dualTowerUpgradeUI.upgradeButton02.onClick.AddListener(UpgradeTowerButton02);
            // 添加双塔升级UI中"出售"按钮的监听器，点击时执行出售塔的操作
            dualTowerUpgradeUI.sellButon.onClick.AddListener(SellTowerButton);
            // 添加双塔升级UI中"交换"按钮的监听器，点击时执行交换塔的操作
            dualTowerUpgradeUI.swapButton.onClick.AddListener(dualTowerUpgradeUI.SwapButton);

            // 获取当前活跃的场景
            currentScene = SceneManager.GetActiveScene();

            // 关闭所有窗口按钮
            CloseAllWindowsButton();

            // 是否启用电池节省模式
            //isBatterySaving = true;
            //BatterySaveMode();

            // 胜利窗口UI的初始化
            getScore = false;
            star01.fillAmount = 0;
            star02.fillAmount = 0;
            star03.fillAmount = 0;
            continueButton.SetActive(false);
            moneyText.gameObject.SetActive(false);
            gemText.gameObject.SetActive(false);

            // 波次管理器中的波次按钮启用
            waveManager.waveButton.SetActive(true);
            // 游戏结束状态初始化
            GameIsOver = false;
            // 游戏开始状态初始化
            BeginGame = false;
            // 切换暂停状态（在场景淡入淡出后修复）
            //TogglePause();

        }

        private void Update()
        {
            // 如果淡入淡出完成，将标志重置为false
            if (fader.doneFading)
            {
                fader.doneFading = false;
            }

            // 如果教程未完成且需要解锁的关卡为2
            if (!PlayerDataManager.TutorialFinished && levelToUnlock == 2)
            {
                // 激活背景图像和教程窗口
                backgroundImage.SetActive(true);
                tutorialWindow.SetActive(true);
            }

            // 如果新敌人索引大于玩家敌人日志索引
            if (newEnemyIndex > PlayerDataManager.EnemyLogIndex)
            {
                // 激活背景图像和敌人信息窗口
                backgroundImage.SetActive(true);
                enemyInfoWindow.SetActive(true);
            }

            // 如果游戏开始且按钮未激活
            if (BeginGame && buttonActive == false)
            {
                // 按钮激活标志设置为true，启用按钮管理器
                buttonActive = true;
                buttonManager.EnableButtons();
            }

            // 如果获取得分标志为true，调用得分计算器
            if (getScore) ScoreCalculator();

            // 如果游戏结束，返回
            if (GameIsOver) return;

            // 如果玩家生命值小于等于0
            if (PlayerStats.Health <= 0)
            {
                // 将玩家得分重置为0，显示游戏结束窗口
                PlayerStats.Score = 0;
                ShowGameOverWindow();
            }
        }

        #region 得分处理器
        // 在这里添加与得分相关的处理逻辑
        #endregion


        public void LevelCompleted()
        {
            // 显示胜利窗口
            ShowVictoryWindow();

            // 如果关卡尚未完成，则传递保存数据
            if (levelToUnlock > PlayerDataManager._levelsUnlocked)
                PlayerDataManager._levelsUnlocked = levelToUnlock;

            // 检查先前是否完成了该关卡
            if (PlayerDataManager.starScoresPerLevel.Count - 1 >= PlayerDataManager._levelsUnlocked - 2)
            {
                // 获取先前的分数
                int prevScore = PlayerDataManager.starScoresPerLevel[levelToUnlock - 2];

                // 如果已经完全完成
                if (prevScore >= GetScore())
                {
                    // 重置奖励
                    rewards.rewardMoney = 0;
                    rewards.rewardGem = 0;
                    rewards.scoreRatio = 0;
                }
                else
                {
                    // 如果先前的分数小于等于2
                    if (GetScore().Equals(3) && prevScore <= 2)
                    {
                        // 分配三星奖励
                        ThreeStarRewards(prevScore);
                    }
                    else if (GetScore().Equals(2) && prevScore <= 1)
                    {
                        // 分配两星奖励
                        TwoStarRewards(prevScore);
                    }
                    else if (GetScore().Equals(1) && prevScore == 0)
                    {
                        // 分配一星奖励
                        OneStarRewards(prevScore);
                    }

                    // 传递保存数据
                    PlayerDataManager.starScoresPerLevel[levelToUnlock - 2] = starScore;
                }
            }
            else // 第一次尝试关卡
            {
                if (GetScore().Equals(3))
                {
                    // 分配三星奖励
                    ThreeStarRewards(0);
                }
                else if (GetScore().Equals(2))
                {
                    // 分配两星奖励
                    TwoStarRewards(0);
                }
                else if (GetScore().Equals(1))
                {
                    // 分配一星奖励
                    OneStarRewards(0);
                }

                // 传递保存数据
                PlayerDataManager.starScoresPerLevel.Add(starScore);
            }

            // 传递保存数据
            PlayerDataManager.Money += rewards.rewardMoney;
            PlayerDataManager.Gem += rewards.rewardGem;

            // 保存传递的数据
            SaveSystem.SaveData(PlayerDataManager.instance);

            // 更新得分数值
            getScore = true;
        }


        private void OneStarRewards(int prevScore)
        {
            starScore = 1;

            // 一星奖励，不进行倍增
            rewards.rewardMoney *= 1;
            rewards.rewardGem *= 1;
        }

        private void TwoStarRewards(int prevScore)
        {
            starScore = 2;

            if (prevScore == 0)
            {
                // 如果之前得分为0，奖励翻倍
                rewards.rewardMoney *= 2;
                rewards.rewardGem *= 2;
            }
            else if (prevScore == 1)
            {
                // 如果之前得分为1，奖励保持原样
                rewards.rewardMoney *= 1;
                rewards.rewardGem *= 1;
            }
        }

        private void ThreeStarRewards(int prevScore)
        {
            starScore = 3;

            if (prevScore == 0)
            {
                // 如果之前得分为0，奖励四倍
                rewards.rewardMoney *= 4;
                rewards.rewardGem *= 4;
            }
            else if (prevScore == 1)
            {
                // 如果之前得分为1，奖励三倍
                rewards.rewardMoney *= 3;
                rewards.rewardGem *= 3;
            }
            else
            {
                // 如果之前得分为2或更高，奖励两倍
                rewards.rewardMoney *= 2;
                rewards.rewardGem *= 2;
            }
        }

        private int GetScore()
        {
            float healthDif = PlayerStats.Health / playerStats.startHealth;

            if (healthDif == 1)
            {
                // 完美健康，得分为3
                return 3;
            }
            else if (healthDif > 0.55 && healthDif < 1)
            {
                // 健康程度较好，得分为2
                return 2;
            }
            else
            {
                // 健康程度较差，得分为1
                return 1;
            }
        }

        private void ScoreCalculator()
        {
            // 根据得分进行奖励计算
            if (GetScore().Equals(1))
            {
                OneStarFill();
            }
            else if (GetScore().Equals(2))
            {
                TwoStarFill();
            }
            else
            {
                ThreeStarFill();
            }

            // 更新玩家界面显示分数和奖励
            UpdateScoreUI();
        }

        #region 三星填充
        private void ThreeStarFill()
        {
            // 填充第一个星星
            star01.fillAmount = Mathf.Clamp01(star01.fillAmount += 0.1f * rewards.fillSpeed * Time.deltaTime);

            if (star01.fillAmount >= 1)
            {
                // 填充第二个星星
                star02.fillAmount = Mathf.Clamp01(star02.fillAmount += 0.1f * rewards.fillSpeed * Time.deltaTime);
            }

            if (star02.fillAmount >= 1)
            {
                // 填充第三个星星
                star03.fillAmount = Mathf.Clamp01(star03.fillAmount += 0.1f * rewards.fillSpeed * Time.deltaTime);
            }

            if (star03.fillAmount >= 1)
            {
                // 显示继续按钮和奖励文本
                continueButton.SetActive(true);
                moneyText.gameObject.SetActive(true);
                gemText.gameObject.SetActive(true);
            }
        }
        #endregion

        #region 两星填充
        private void TwoStarFill()
        {
            // 填充第一个星星
            star01.fillAmount = Mathf.Clamp01(star01.fillAmount += 0.1f * rewards.fillSpeed * Time.deltaTime);

            if (star01.fillAmount >= 1)
            {
                // 填充第二个星星
                star02.fillAmount = Mathf.Clamp01(star02.fillAmount += 0.1f * rewards.fillSpeed * Time.deltaTime);
            }

            if (star02.fillAmount >= 1)
            {
                // 显示继续按钮和奖励文本
                continueButton.SetActive(true);
                moneyText.gameObject.SetActive(true);
                gemText.gameObject.SetActive(true);
            }
        }
        #endregion

        #region 一星填充
        private void OneStarFill()
        {
            // 填充第一个星星
            star01.fillAmount = Mathf.Clamp01(star01.fillAmount += 0.1f * rewards.fillSpeed * Time.deltaTime);

            if (star01.fillAmount >= 1)
            {
                // 显示继续按钮和奖励文本
                continueButton.SetActive(true);
                moneyText.gameObject.SetActive(true);
                gemText.gameObject.SetActive(true);
            }
        }
        #endregion

        #region 更新分数界面
        private void UpdateScoreUI()
        {
            // 更新奖励文本
            moneyText.text = "+" + rewards.rewardMoney.ToString();
            gemText.text = "+" + rewards.rewardGem.ToString();

            // 更新分数并限制在一定范围内
            PlayerStats.Score = Mathf.Clamp(PlayerStats.Score += 10f * rewards.fillSpeed * Time.deltaTime, 0, GetScore() * rewards.scoreRatio);
            scoreText.text = "Score: " + PlayerStats.Score.ToString("0");
        }
        #endregion

        #region 节点UI处理器

        /// <summary>
        /// 选择建造节点，将节点传递给游戏管理器以便访问该特定节点上的塔数据。
        /// </summary>
        /// <param name="ground">建造节点</param>
        public void SelectBuildGround(BuildNode ground)
        {
            // 如果已经选择了相同的建造节点，则取消选择并返回
            // if (selectedBuildNode == ground)
            // {
            //     DeselectBuildGround();
            //     return;
            // }

            DeselectBuildGround(); // 取消之前的选择
            selectedBuildNode = ground; // 设置当前选择的建造节点为传入的节点
            selectedBuildNode.SetColor(selectedBuildNode.activeColor); // 设置节点的颜色为活动颜色

            towerToBuild = null; // 重置要建造的塔
            SetBuildTarget(ground); // 设置建造目标为当前节点
        }

        /// <summary>
        /// 取消建造节点的选择状态
        /// </summary>
        public void DeselectBuildGround()
        {
            if (selectedBuildNode != null)
            {
                selectedBuildNode.SetColor(selectedBuildNode.startColor); // 恢复节点初始颜色
                selectedBuildNode.isSelected = false; // 取消选择状态

                if (selectedBuildNode.tower != null)
                {
                    selectedBuildNode.towerScript.HideRangeUI(); // 隐藏塔的范围UI
                }
            }

            selectedBuildNode = null; // 重置当前选择的建造节点

            // 关闭所有塔UI窗口
            CloseAllWindowsButton();
        }

        /// <summary>
        /// 根据建造节点上是否存在塔来显示相应的UI（商店或升级）。
        /// </summary>
        /// <param name="_target">建造目标节点</param>
        public void SetBuildTarget(BuildNode _target)
        {
            selectedBuildNode = _target; // 设置当前选择的建造节点为传入的节点

            if (_target.tower != null) // 如果建造节点上已经存在塔
            {
                selectedBuildNode.towerScript.ShowRangeUI(); // 显示塔的范围UI

                if (_target.towerBlueprint.upgrade02 != null) // 如果存在第二级升级
                {
                    InitDualUpgradeUI(); // 初始化双重升级UI
                    ShowDualUpgradeWindow(); // 显示双重升级窗口
                }
                else
                {
                    InitUpgradeUI(); // 初始化升级UI
                    ShowUpgradeWindow(); // 显示升级窗口
                }
            }
            else // 如果建造节点上不存在塔
            {
                ShowShopWindow(); // 显示商店窗口
            }
        }

        #endregion


        #region 按钮功能

        // 打开设置界面
        public void OpenSettings()
        {
            Time.timeScale = 0;  // 暂停游戏时间

            backgroundImage.SetActive(true);  // 激活背景图
            settingsWindow.SetActive(true);  // 激活设置窗口
        }

        // 恢复游戏
        public void ResumeGame()
        {
            if (buttonManager.isFastFowarded)
                Time.timeScale = 2;  // 如果快进按钮被按下，时间加速为2倍
            else
                Time.timeScale = 1;  // 否则，时间正常流逝

            backgroundImage.SetActive(false);  // 关闭背景图
            settingsWindow.SetActive(false);  // 关闭设置窗口
        }

        // 返回主菜单
        public void ReturnToMainMenu()
        {
            Time.timeScale = 1;  // 恢复正常时间流逝

            fader.FadeTo(StringData.mainScene);  // 切换到主场景
        }

        // 重试关卡
        public void RetryLevel()
        {
            Time.timeScale = 1;  // 恢复正常时间流逝

            SceneManager.LoadScene(currentScene.buildIndex);  // 重新加载当前关卡
        }

        // 实例化塔按钮功能
        public void InstantiateTowerButton()
        {
            // 如果已存在塔，直接返回
            if (selectedBuildNode.tower != null)
                return;

            // 如果不能建造，直接返回
            if (CanBuild == false)
                return;

            // 如果可以购买
            if (CanPurchase)
            {
                PlayerStats.Gold -= towerToBuild.cost;  // 扣除金币
                GameObject _tower = Instantiate(towerToBuild.towerPrefab, selectedBuildNode.GetBuildPosition(), towerToBuild.towerPrefab.transform.rotation);

                Instantiate(buildEffect, selectedBuildNode.GetBuildPosition(), towerToBuild.towerPrefab.transform.rotation);
                audioManager.buildAudio.Play();  // 播放建造音效

                selectedBuildNode.towerBlueprint = towerToBuild;
                selectedBuildNode.tower = _tower;
                selectedBuildNode.towerScript = _tower.GetComponent<Tower>();
                selectedBuildNode.rend.material.color = selectedBuildNode.startColor;
            }

            CloseAllWindowsButton();  // 关闭所有窗口
        }

        // 关闭所有窗口按钮功能
        public void CloseAllWindowsButton()
        {
            settingsWindow.SetActive(false);
            shopWindow.SetActive(false);
            upgradeWindow.SetActive(false);
            dualUpgradeWindow.SetActive(false);
            confirmationWindow.SetActive(false);
        }

        #endregion

        // 关闭确认窗口按钮功能
        public void CloseConfirmationWindow()
        {
            shopWindow.SetActive(true);  // 激活商店窗口
            confirmationWindow.SetActive(false);  // 关闭确认窗口
        }

        // 升级塔按钮功能（选项1）
        public void UpgradeTowerButton01()
        {
            selectedBuildNode.UpgradeTurret01();  // 调用选中建造节点的升级塔方法（选项1）
            DeselectBuildGround();  // 取消建造节点的选择
        }

        // 升级塔按钮功能（选项2）
        public void UpgradeTowerButton02()
        {
            selectedBuildNode.UpgradeTurret02();  // 调用选中建造节点的升级塔方法（选项2）
            DeselectBuildGround();  // 取消建造节点的选择
        }

        // 出售塔按钮功能
        public void SellTowerButton()
        {
            selectedBuildNode.SellTower();  // 调用选中建造节点的出售塔方法
            SellTowerEffect();  // 播放出售塔特效

            DeselectBuildGround();  // 取消建造节点的选择
        }

        // 播放出售塔特效
        public void SellTowerEffect()
        {
            Instantiate(sellEffect, selectedBuildNode.GetBuildPosition(), sellEffect.transform.rotation);  // 在建造位置实例化出售特效
            audioManager.sellAudio.Play();  // 播放出售音效
        }

        // 完成教程按钮功能
        public void FinishTutorialButton()
        {
            PlayerDataManager.TutorialFinished = true;  // 设置教程完成标志为真
            tutorialWindow.SetActive(false);  // 关闭教程窗口
            backgroundImage.SetActive(false);  // 关闭背景图
        }

        // 新敌人警报按钮功能
        public void NewEnemyAlertButton()
        {
            if (newEnemyAlertWindow == null || newEnemyThisLevel == null) return;

            // 如果新敌人警报信息与当前敌人信息相符，更新玩家敌人日志索引
            if (newEnemyAlertWindow.enemyLogInfo.Equals(newEnemyThisLevel))
                PlayerDataManager.EnemyLogIndex = newEnemyIndex;

            backgroundImage.SetActive(false);  // 关闭背景图
            enemyInfoWindow.SetActive(false);  // 关闭敌人信息窗口
        }

        //public void BatterySaveMode()
        //{
        //    isBatterySaving = !isBatterySaving;

        //    if (isBatterySaving)
        //    {
        //        lowEndPath.SetActive(true);
        //        highEndPath.SetActive(false);
        //        batteryButtonImage.sprite = onButtonSprite;
        //        toggleText.text = "ON";
        //    }
        //    else
        //    {
        //        highEndPath.SetActive(true);
        //        lowEndPath.SetActive(false);
        //        batteryButtonImage.sprite = offButtonSprite;
        //        toggleText.text = "OFF";
        //    }
        //}

        #endregion

        #region 升级界面初始化

        // 初始化升级界面
        private void InitUpgradeUI()
        {
            // 如果建造节点尚未升级
            if (!selectedBuildNode.isUpgraded)
            {
                // 获取升级后的塔数据
                TowerData upgradedTowerData = selectedBuildNode.towerBlueprint.upgrade01;

                // 如果升级后的塔数据为空
                if (upgradedTowerData == null)
                {
                    // 将升级界面置空并显示初始塔信息
                    towerUpgradeUI.NullifyUI(upgradedTowerData, selectedBuildNode.towerBlueprint);
                    towerUpgradeUI.towerSprite.sprite = selectedBuildNode.towerBlueprint.icon;
                    towerUpgradeUI.sellValueText.text = selectedBuildNode.towerBlueprint.sellValue.ToString();
                    towerUpgradeUI.UpdateUI(null, selectedBuildNode.towerBlueprint);
                    towerUpgradeUI.upgradeButton.interactable = false;
                    towerUpgradeUI.upgradeButton.gameObject.SetActive(false);
                    return;
                }

                // 更新升级界面显示，激活升级按钮
                towerUpgradeUI.UpdateUI(upgradedTowerData, selectedBuildNode.towerBlueprint);
                towerUpgradeUI.upgradeButton.gameObject.SetActive(true);
                towerUpgradeUI.upgradeButton.interactable = true;
            }
            else
            {
                // 如果建造节点已经升级，隐藏升级按钮
                towerUpgradeUI.upgradeButton.gameObject.SetActive(false);
            }
        }


        private void InitDualUpgradeUI()
        {
            // 如果建造节点尚未升级
            if (!selectedBuildNode.isUpgraded)
            {
                // 获取升级后的两种塔数据
                TowerData upgradedTower01 = selectedBuildNode.towerBlueprint.upgrade01;
                TowerData upgradedTower02 = selectedBuildNode.towerBlueprint.upgrade02;

                // 如果任一升级后的塔数据为空
                if (upgradedTower01 == null || upgradedTower02 == null)
                {
                    // 将升级界面置空并显示初始塔信息
                    dualTowerUpgradeUI.towerSprite.sprite = selectedBuildNode.towerBlueprint.icon;
                    dualTowerUpgradeUI.sellValueText01.text = selectedBuildNode.towerBlueprint.sellValue.ToString();
                    dualTowerUpgradeUI.UpdateUI(null, null, selectedBuildNode.towerBlueprint);
                    dualTowerUpgradeUI.upgradeButton01.gameObject.SetActive(false);
                    dualTowerUpgradeUI.upgradeButton02.gameObject.SetActive(false);
                    dualTowerUpgradeUI.upgradeButton01.interactable = false;
                    dualTowerUpgradeUI.upgradeButton02.interactable = false;
                    return;
                }

                // 更新升级界面显示，激活两个升级按钮
                dualTowerUpgradeUI.UpdateUI(upgradedTower01, upgradedTower02, selectedBuildNode.towerBlueprint);
                dualTowerUpgradeUI.upgradeButton01.gameObject.SetActive(true);
                dualTowerUpgradeUI.upgradeButton02.gameObject.SetActive(true);
                dualTowerUpgradeUI.upgradeButton01.interactable = true;
                dualTowerUpgradeUI.upgradeButton02.interactable = true;
            }
            else
            {
                // 如果建造节点已经升级，隐藏两个升级按钮
                dualTowerUpgradeUI.upgradeButton01.gameObject.SetActive(false);
                dualTowerUpgradeUI.upgradeButton02.gameObject.SetActive(false);
            }
        }

        #endregion

        #region 窗口界面

        // 显示确认窗口按钮
        public void ShowConfirmationWindowButton(TowerData data)
        {
            // 关闭所有窗口
            CloseAllWindowsButton();
            // 设置待建造的塔数据
            towerToBuild = data;

            // 激活确认窗口
            confirmationWindow.SetActive(true);

            // 更新确认窗口UI
            confirmationTowerUI.UpdateUI(data);
        }

        // 显示升级窗口
        private void ShowUpgradeWindow()
        {
            upgradeWindow.SetActive(true);
        }

        // 显示双重升级窗口
        private void ShowDualUpgradeWindow()
        {
            dualUpgradeWindow.SetActive(true);
        }

        // 显示商店窗口
        private void ShowShopWindow()
        {
            shopWindow.SetActive(true);
        }

        // 显示胜利窗口
        private void ShowVictoryWindow()
        {
            // 激活背景图和胜利窗口
            backgroundImage.SetActive(true);
            victoryWindow.SetActive(true);
        }

        // 显示游戏结束窗口
        private void ShowGameOverWindow()
        {
            // 恢复游戏时间流逝速度
            Time.timeScale = 1;

            // 设置游戏结束标志
            GameIsOver = true;
            // 激活背景图和游戏结束窗口
            backgroundImage.SetActive(true);
            gameOverWindow.SetActive(true);
        }

        #endregion

    }
}